/**
* 版权声明：厦门睿商网络科技有限公司 版权所有 违者必究
* 日    期：2020-04-11
*/
package com.rzico.order.service;

import com.rzico.base.BaseMapper;
import com.rzico.base.impl.BaseServiceImpl;
import com.rzico.basics.entity.Product;
import com.rzico.basics.service.ProductService;
import com.rzico.order.entity.*;
import com.rzico.order.model.WarehouseStockVo;
import com.rzico.util.RedisHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.rzico.order.mapper.WarehouseStockMapper;
import org.springframework.transaction.annotation.Transactional;
import com.rzico.order.enumx.*;

import java.math.BigDecimal;
import java.util.List;
import java.util.Map;

/**
 * <pre>
 * 库存表业务类
 * </pre>
 *
 * @author Rzico Boot
 * @version 1.0
 */
@Service
public class WarehouseStockService extends BaseServiceImpl<WarehouseStock, String> {

    protected Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private WarehouseStockMapper warehouseStockMapper;

    @Autowired
    private ProductService productService;

    @Autowired
    private RedisHandler redisHandler;

    @Override
    public BaseMapper<WarehouseStock, String> getMapper() {
        return warehouseStockMapper;
    }


    public List<WarehouseStockVo> selectLastStockList(Map<String, Object> params){
        List<WarehouseStockVo> list = warehouseStockMapper.selectLastStockList(params);
        return list;
    }

    /**
     * 采购入库，入库单已确认：待入库 + 入库数量
     * 采购入库，入库单已完成：库存量 + 入库数量，待入库 - 入库数量
     *
     * 采购退货，出库单已确认：待出库 + 退货数量
     * 采购退货，出库单已完成：库存量 - 退货数量，待出库 - 退货数量
     *
     * 调拨入库，入库单未确认：待入库 + 入库数量
     * 调拨入库，入库单已完成：库存量 + 入库数量，待入库 - 入库数量
     *
     * 调拨出库，出库单已确认：待出库 + 出库数量
     * 调拨出库，出库单已完成：库存量 - 出库数量，待出库 - 出库数量
     *
     * 销售出库，出库单已确认：待出库 + 销售数量
     * 销售出库，出库单已完成：库存量 - 销售数量，待出库 - 销售数量
     *
     * 销售退货，出库单已确认：待入库 + 退货数量
     * 销售退货，出库单已完成：库存量 + 退货数量，待入库 - 退货数量
     *
     * 盘点损益，出库单已确认：待出库 + 损益数量
     * 盘点损益，出库单已完成：库存量 - 损益数量， 待出库 - 损益数量
     *
     * 其他出库，出库单已确认：待出库 + 出库数量
     * 其他出库，出库单已完成：库存量 - 出库数量， 待出库 - 出库数量
     */

    /**
     * 预出入库(出入库单未确认状态)
     * @param warehouseType
     * @param warehouseItem
     * @return
     */
    public int preHandle(Integer warehouseType, WarehouseItem warehouseItem){
        logger.info("enterpriseId ===== [{}]", warehouseItem.getEnterpriseId());
        logger.info("shopId =========== [{}]", warehouseItem.getShopId());
        logger.info("productId ======== [{}]", warehouseItem.getProductId());
        logger.info("sn================ [{}]", warehouseItem.getSn());
        logger.info("spec============== [{}]", warehouseItem.getSpec());
        int result = 0;
        WarehouseTypeEnum warehouseTypeEnum = WarehouseTypeEnum.getById(warehouseType);
        switch (warehouseTypeEnum){
            case WAREHOUSE_TYPE_PURCHASE_IN:
                result = prePurchaseIn(warehouseItem);
                break;
            case WAREHOUSE_TYPE_PURCHASE_OUT:
                result = prePurchaseOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_ALLOCATE_IN:
                result = preTransferIn(warehouseItem);
                break;
            case WAREHOUSE_TYPE_SALE_OUT:
                result = preSaleOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_SALE_IN:
                result = preSaleIn(warehouseItem);
                break;
            case WAREHOUSE_TYPE_ALLOCATE_OUT:
                result = preTransferOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_CHECK_OUT:
                result = preCheckOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_OTHER_OUT:
                result = preOtherOut(warehouseItem);
                break;
            default:
                break;
        }
        return result;
    }

    public int afterCompletion(Integer warehouseType, WarehouseItem warehouseItem){
        logger.info("enterpriseId ===== [{}]", warehouseItem.getEnterpriseId());
        logger.info("shopId =========== [{}]", warehouseItem.getShopId());
        logger.info("productId ======== [{}]", warehouseItem.getProductId());
        logger.info("sn================ [{}]", warehouseItem.getSn());
        logger.info("spec============== [{}]", warehouseItem.getSpec());
        int result = 0;
        WarehouseTypeEnum warehouseTypeEnum = WarehouseTypeEnum.getById(warehouseType);
        switch (warehouseTypeEnum){
            case WAREHOUSE_TYPE_PURCHASE_IN:
                result = afterPurchaseIn(warehouseItem);
                break;
            case WAREHOUSE_TYPE_PURCHASE_OUT:
                result = afterPurchaseOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_ALLOCATE_IN:
                result = afterTransferIn(warehouseItem);
                break;
            case WAREHOUSE_TYPE_SALE_OUT:
                result = afterSaleOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_SALE_IN:
                result = afterSaleIn(warehouseItem);
                break;
            case WAREHOUSE_TYPE_ALLOCATE_OUT:
                result = afterTransferOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_CHECK_OUT:
                result = afterCheckOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_OTHER_OUT:
                result = afterOtherOut(warehouseItem);
                break;
            default:
                break;
        }
        return result;
    }

    /**
     * 采购预入库
     * @param warehouseItem
     * @return
     */
    public int prePurchaseIn(WarehouseItem warehouseItem){
        int affectCount = 0;
        WarehouseStock whs = selectStock(warehouseItem);
        if (null == whs){
            WarehouseStock warehouseStock = new WarehouseStock();
            Product product = productService.selectByPrimaryKey(warehouseItem.getProductId());
            warehouseStock.setEnterpriseId(warehouseItem.getEnterpriseId());
            warehouseStock.setShopId(warehouseItem.getShopId());
            warehouseStock.setGoodsId(product.getGoodsId());
            warehouseStock.setProductId(warehouseItem.getMainProductId());
            warehouseStock.setStock(BigDecimal.ZERO);
            warehouseStock.setAllocatedStock(BigDecimal.ZERO);
            warehouseStock.setCost(product.getCost());
            warehouseStock.setPendingStock(warehouseItem.getMainProductQuantity());
            affectCount = insertUseGeneratedKeys(warehouseStock);
        }else{
            //update
   /*         BigDecimal pendingStock = whs.getPendingStock().add(warehouseItem.getQuantity());
            whs.setPendingStock(pendingStock);
            affectCount = super.updateByPrimaryKeySelective(whs);*/
            whs.setQuantity(warehouseItem.getMainProductQuantity());
            affectCount = warehouseStockMapper.pendingStockPlus(whs);
        }
        return affectCount;
    }

    /**
     * 采购确认入库
     * @param warehouseItem
     * @return
     */
    public int afterPurchaseIn(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);

     /*   BigDecimal stock = whs.getStock().add(warehouseItem.getQuantity());
        BigDecimal pendingStock = whs.getPendingStock().subtract(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setPendingStock(pendingStock);
        affectCount = super.updateByPrimaryKeySelective(whs);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.stockPlusAndPendingSubtract(whs);
    }

    /**
     * 采购退货预出库
     * @param warehouseItem
     * @return
     */
    public int prePurchaseOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
/*
        BigDecimal allocatedStock = whs.getAllocatedStock().add(warehouseItem.getQuantity());
        whs.setAllocatedStock(allocatedStock);
        affectCount = super.updateByPrimaryKeySelective(whs);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.allocatedStockPlus(whs);
    }

    /**
     * 采购退货确认出库
     * @param warehouseItem
     * @return
     */
    public int afterPurchaseOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);

    /*    BigDecimal stock = whs.getStock().subtract(warehouseItem.getQuantity());
        BigDecimal allocatedStock = whs.getAllocatedStock().subtract(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setAllocatedStock(allocatedStock);
        affectCount = super.updateByPrimaryKeySelective(whs);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.stockSubtractAndAllocatedSubtract(whs);
    }


    /**
     * 调拨预入库
     * @param warehouseItem
     * @return
     */
    public int preTransferIn(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);

       /* BigDecimal pendingStock = whs.getPendingStock().add(warehouseItem.getQuantity());
        whs.setPendingStock(pendingStock);
        affectCount = super.updateByPrimaryKeySelective(whs);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.pendingStockPlus(whs);
    }



    /**
     * 调拨确认入库
     * @param warehouseItem
     * @return
     */
    public int afterTransferIn(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);

        /*BigDecimal stock = whs.getStock().add(warehouseItem.getQuantity());
        BigDecimal pendingStock = whs.getPendingStock().subtract(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setPendingStock(pendingStock);
        affectCount = super.updateByPrimaryKeySelective(whs);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());

        return warehouseStockMapper.stockPlusAndPendingSubtract(whs);
    }


    /**
     * 调拨预出库
     * @param warehouseItem
     * @return
     */
    public int preTransferOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);

        /*BigDecimal allocatedStock = whs.getAllocatedStock().add(warehouseItem.getQuantity());
        whs.setAllocatedStock(allocatedStock);
        affectCount = super.updateByPrimaryKeySelective(whs);*/

        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.allocatedStockPlus(whs);
    }

    /**
     * 调拨确认出库
     * @param warehouseItem
     * @return
     */
    public int afterTransferOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);

 /*       BigDecimal stock = whs.getStock().subtract(warehouseItem.getQuantity());
        BigDecimal allocatedStock = whs.getAllocatedStock().subtract(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setAllocatedStock(allocatedStock);
        affectCount = super.updateByPrimaryKeySelective(whs);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.stockSubtractAndAllocatedSubtract(whs);
    }


    /**
     * 销售预出库
     * @param warehouseItem
     * @return
     */
    public int preSaleOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);

     /*   BigDecimal allocatedStock = whs.getAllocatedStock().add(warehouseItem.getQuantity());
        whs.setAllocatedStock(allocatedStock);
        affectCount = super.updateByPrimaryKeySelective(whs);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.allocatedStockPlus(whs);
    }

    /**
     * 销售确认出库
     * @param warehouseItem
     * @return
     */
    public int afterSaleOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);

/*        BigDecimal stock = whs.getStock().subtract(warehouseItem.getQuantity());
        BigDecimal allocatedStock = whs.getAllocatedStock().subtract(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setAllocatedStock(allocatedStock);
        affectCount = super.updateByPrimaryKeySelective(whs);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.stockSubtractAndAllocatedSubtract(whs);
    }


    /**
     * 销售退货预入库
     * @param warehouseItem
     * @return
     */
    public int preSaleIn(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);

      /*  BigDecimal pendingStock = whs.getPendingStock().add(warehouseItem.getQuantity());
        whs.setPendingStock(pendingStock);
        affectCount = super.updateByPrimaryKeySelective(whs);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.pendingStockPlus(whs);
    }



    /**
     * 销售退货确认入库
     * @param warehouseItem
     * @return
     */
    public int afterSaleIn(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);

        /*BigDecimal stock = whs.getStock().add(warehouseItem.getQuantity());
        BigDecimal pendingStock = whs.getPendingStock().subtract(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setPendingStock(pendingStock);
        affectCount = super.updateByPrimaryKeySelective(whs);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());

        return warehouseStockMapper.stockPlusAndPendingSubtract(whs);
    }


    /**
     * 盘点损益预出库
     * @param warehouseItem
     * @return
     */
    public int preCheckOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);

        /*BigDecimal allocatedStock = whs.getAllocatedStock().add(warehouseItem.getQuantity());
        whs.setAllocatedStock(allocatedStock);
        affectCount = super.updateByPrimaryKeySelective(whs);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.pendingStockPlus(whs);
    }

    /**
     * 盘点损益确认出库
     * @param warehouseItem
     * @return
     */
    public int afterCheckOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);

        /*BigDecimal stock = whs.getStock().subtract(warehouseItem.getQuantity());
        BigDecimal allocatedStock = whs.getAllocatedStock().subtract(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setAllocatedStock(allocatedStock);
        affectCount = super.updateByPrimaryKeySelective(whs);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.stockPlusAndPendingSubtract(whs);
    }

    /**
     * 其他预出库
     * @param warehouseItem
     * @return
     */
    public int preOtherOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);

        /*BigDecimal allocatedStock = whs.getAllocatedStock().add(warehouseItem.getQuantity());
        whs.setAllocatedStock(allocatedStock);
        affectCount = super.updateByPrimaryKeySelective(whs);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.allocatedStockPlus(whs);
    }

    /**
     * 其他确认出库
     * @param warehouseItem
     * @return
     */
    public int afterOtherOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);

        /*BigDecimal stock = whs.getStock().subtract(warehouseItem.getQuantity());
        BigDecimal allocatedStock = whs.getAllocatedStock().subtract(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setAllocatedStock(allocatedStock);
        affectCount = super.updateByPrimaryKeySelective(whs);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.stockSubtractAndAllocatedSubtract(whs);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int insertUseGeneratedKeys(WarehouseStock warehouseStock) {
        return super.insertUseGeneratedKeys(warehouseStock);
    }


    public WarehouseStock selectStock(WarehouseItem warehouseItem){
        String key = "warehouseStock-"+String.valueOf(warehouseItem.getEnterpriseId()).concat("-").
                concat(String.valueOf(warehouseItem.getMainProductId())).concat("-").concat(String.valueOf(warehouseItem.getShopId()));
        String value = key;
        while (!redisHandler.lock(key,value)) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            WarehouseStock params = new WarehouseStock();
            params.setEnterpriseId(warehouseItem.getEnterpriseId());
            params.setShopId(warehouseItem.getShopId());
            params.setProductId(warehouseItem.getMainProductId());
            List<WarehouseStock> warehouseStockList = warehouseStockMapper.select(params);
            WarehouseStock warehouseStock = null;
            if (warehouseStockList.size() > 0) {
                warehouseStock = warehouseStockList.get(0);
            }
            if (warehouseStock == null) {
                warehouseStock = new WarehouseStock();
                Product product = productService.selectByPrimaryKey(warehouseItem.getMainProductId());
                warehouseStock.setEnterpriseId(warehouseItem.getEnterpriseId());
                warehouseStock.setShopId(warehouseItem.getShopId());
                warehouseStock.setGoodsId(product.getGoodsId());
                warehouseStock.setProductId(warehouseItem.getMainProductId());
                warehouseStock.setStock(BigDecimal.ZERO);
                warehouseStock.setAllocatedStock(BigDecimal.ZERO);
                warehouseStock.setCost(BigDecimal.ZERO);
                warehouseStock.setPendingStock(BigDecimal.ZERO);
                warehouseStock.setAllocatedStock(BigDecimal.ZERO);
                super.insertUseGeneratedKeys(warehouseStock);
            }
            return warehouseStock;
        } finally {
            redisHandler.unlock(key,value);
        }
    }


    /**
     * 反转操作出入库单（弃审）
     *
     * 采购入库，入库单已完成：库存量 - 入库数量，待入库 + 入库数量
     * 采购入库，入库单已确认：待入库 - 入库数量
     *
     * 采购退货，出库单已完成：库存量 + 退货数量，待出库 + 退货数量
     * 采购退货，出库单已确认：待出库 - 退货数量
     *
     * 调拨入库，入库单已完成：库存量 - 入库数量，待入库 + 入库数量
     * 调拨入库，入库单已确认：待入库 - 入库数量
     *
     * 调拨出库，出库单已完成：库存量 + 出库数量，待出库 + 出库数量
     * 调拨出库，出库单已确认：待出库 - 出库数量
     *
     * 销售出库，出库单已完成：库存量 + 销售数量，待出库 + 销售数量
     * 销售出库，出库单已确认：待出库 - 销售数量
     *
     * 销售退货，出库单已完成：库存量 - 退货数量，待入库 + 退货数量
     * 销售退货，出库单未确认：待入库 - 退货数量
     *
     * 盘点损益，出库单已完成：库存量 + 损益数量， 待出库 + 损益数量
     * 盘点损益，出库单已确认：待出库 - 损益数量
     *
     * 其他出库，出库单已完成：库存量 + 出库数量， 待出库 + 出库数量
     * 其他出库，出库单已确认：待出库 - 出库数量
     */


    /**
     * 取消“已完成”状态的出入库单至“已确认”
     * @param warehouseType
     * @param warehouseItem
     * @return
     */
    public int preCancelHandle(Integer warehouseType, WarehouseItem warehouseItem){
        logger.info("enterpriseId ===== [{}]", warehouseItem.getEnterpriseId());
        logger.info("shopId =========== [{}]", warehouseItem.getShopId());
        logger.info("productId ======== [{}]", warehouseItem.getProductId());
        logger.info("sn================ [{}]", warehouseItem.getSn());
        logger.info("spec============== [{}]", warehouseItem.getSpec());
        int result = 0;
        WarehouseTypeEnum warehouseTypeEnum = WarehouseTypeEnum.getById(warehouseType);
        switch (warehouseTypeEnum){
            case WAREHOUSE_TYPE_PURCHASE_IN:
                result = preCancelPurchaseIn(warehouseItem);
                break;
            case WAREHOUSE_TYPE_PURCHASE_OUT:
                result = preCancelPurchaseOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_ALLOCATE_IN:
                result = preCancelTransferIn(warehouseItem);
                break;
            case WAREHOUSE_TYPE_SALE_OUT:
                result = preCancelSaleOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_SALE_IN:
                result = preCancelSaleIn(warehouseItem);
                break;
            case WAREHOUSE_TYPE_ALLOCATE_OUT:
                result = preCancelTransferOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_CHECK_OUT:
                result = preCancelCheckOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_OTHER_OUT:
                result = preCancelOtherOut(warehouseItem);
                break;
            default:
                break;
        }
        return result;
    }


    /**
     * 取消“已确认”状态的出入库单至“未确认”
     * @param warehouseType
     * @param warehouseItem
     * @return
     */
    public int afterCancelCompletion(Integer warehouseType, WarehouseItem warehouseItem){
        logger.info("enterpriseId ===== [{}]", warehouseItem.getEnterpriseId());
        logger.info("shopId =========== [{}]", warehouseItem.getShopId());
        logger.info("productId ======== [{}]", warehouseItem.getProductId());
        logger.info("sn================ [{}]", warehouseItem.getSn());
        logger.info("spec============== [{}]", warehouseItem.getSpec());
        int result = 0;
        WarehouseTypeEnum warehouseTypeEnum = WarehouseTypeEnum.getById(warehouseType);
        switch (warehouseTypeEnum){
            case WAREHOUSE_TYPE_PURCHASE_IN:
                result = afterCancelPurchaseIn(warehouseItem);
                break;
            case WAREHOUSE_TYPE_PURCHASE_OUT:
                result = afterCancelPurchaseOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_ALLOCATE_IN:
                result = afterCancelTransferIn(warehouseItem);
                break;
            case WAREHOUSE_TYPE_SALE_OUT:
                result = afterCancelSaleOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_SALE_IN:
                result = afterCancelSaleIn(warehouseItem);
                break;
            case WAREHOUSE_TYPE_ALLOCATE_OUT:
                result = afterCancelTransferOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_CHECK_OUT:
                result = afterCancelCheckOut(warehouseItem);
                break;
            case WAREHOUSE_TYPE_OTHER_OUT:
                result = afterCancelOtherOut(warehouseItem);
                break;
            default:
                break;
        }
        return result;
    }

    /**
     * 弃审“已完成”采购入库
     * @param warehouseItem
     * @return
     */
    public int preCancelPurchaseIn(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
   /*     BigDecimal stock = whs.getStock().subtract(warehouseItem.getQuantity());
        BigDecimal pendingStock = whs.getPendingStock().add(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setPendingStock(pendingStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.stockSubtractAndPendingPlus(whs);
    }

    /**
     * 弃审“已确认”采购入库
     * @param warehouseItem
     * @return
     */
    public int afterCancelPurchaseIn(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
      /*  BigDecimal pendingStock = whs.getPendingStock().subtract(warehouseItem.getQuantity());
        whs.setPendingStock(pendingStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.pendingStockSubtract(whs);
    }


    /**
     * 弃审“已完成”采购退货
     * @param warehouseItem
     * @return
     */
    public int preCancelPurchaseOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
      /*  BigDecimal stock = whs.getStock().add(warehouseItem.getQuantity());
        BigDecimal allocatedStock = whs.getAllocatedStock().add(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setAllocatedStock(allocatedStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.stockPlusAndAllocatedPlus(whs);
    }


    /**
     * 弃审“已确认”采购退货
     * @param warehouseItem
     * @return
     */
    public int afterCancelPurchaseOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
        /*BigDecimal allocatedStock = whs.getAllocatedStock().subtract(warehouseItem.getQuantity());
        whs.setAllocatedStock(allocatedStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.allocatedStockSubtract(whs);
    }


    /**
     * 弃审“已完成”调拨入库
     * @param warehouseItem
     * @return
     */
    public int preCancelTransferIn(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
      /*  BigDecimal stock = whs.getStock().subtract(warehouseItem.getQuantity());
        BigDecimal pendingStock = whs.getPendingStock().add(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setPendingStock(pendingStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.stockSubtractAndPendingPlus(whs);
    }


    /**
     * 弃审“已确认”调拨入库
     * @param warehouseItem
     * @return
     */
    public int afterCancelTransferIn(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
       /* BigDecimal pendingStock = whs.getPendingStock().subtract(warehouseItem.getQuantity());
        whs.setPendingStock(pendingStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.pendingStockSubtract(whs);
    }


    /**
     * 弃审“已完成”调拨出库
     * @param warehouseItem
     * @return
     */
    public int preCancelTransferOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
        /*BigDecimal stock = whs.getStock().add(warehouseItem.getQuantity());
        BigDecimal allocatedStock = whs.getAllocatedStock().add(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setAllocatedStock(allocatedStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.stockPlusAndAllocatedPlus(whs);
    }


    /**
     * 弃审“已确认”调拨出库
     * @param warehouseItem
     * @return
     */
    public int afterCancelTransferOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
        /*BigDecimal allocatedStock = whs.getAllocatedStock().subtract(warehouseItem.getQuantity());
        whs.setAllocatedStock(allocatedStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.allocatedStockSubtract(whs);
    }




    /**
     * 弃审“已完成”销售出库
     * @param warehouseItem
     * @return
     */
    public int preCancelSaleOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
        /*BigDecimal stock = whs.getStock().add(warehouseItem.getQuantity());
        BigDecimal allocatedStock = whs.getAllocatedStock().add(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setAllocatedStock(allocatedStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.stockPlusAndAllocatedPlus(whs);
    }


    /**
     * 弃审“已确认”销售出库
     * @param warehouseItem
     * @return
     */
    public int afterCancelSaleOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
       /* BigDecimal allocatedStock = whs.getAllocatedStock().subtract(warehouseItem.getQuantity());
        whs.setAllocatedStock(allocatedStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.allocatedStockSubtract(whs);
    }


    /**
     * 弃审“已完成”销售退货
     * @param warehouseItem
     * @return
     */
    public int preCancelSaleIn(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
       /* BigDecimal stock = whs.getStock().subtract(warehouseItem.getQuantity());
        BigDecimal pendingStock = whs.getPendingStock().add(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setPendingStock(pendingStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.stockSubtractAndPendingPlus(whs);
    }


    /**
     * 弃审“已确认”销售退货
     * @param warehouseItem
     * @return
     */
    public int afterCancelSaleIn(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
      /*  BigDecimal pendingStock = whs.getPendingStock().subtract(warehouseItem.getQuantity());
        whs.setPendingStock(pendingStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.pendingStockSubtract(whs);
    }



    /**
     * 弃审“已完成”盘点损益
     * @param warehouseItem
     * @return
     */
    public int preCancelCheckOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
       /* BigDecimal stock = whs.getStock().add(warehouseItem.getQuantity());
        BigDecimal allocatedStock = whs.getAllocatedStock().add(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setAllocatedStock(allocatedStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.stockPlusAndAllocatedPlus(whs);
    }


    /**
     * 弃审“已确认”盘点损益
     * @param warehouseItem
     * @return
     */
    public int afterCancelCheckOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
       /* BigDecimal allocatedStock = whs.getAllocatedStock().subtract(warehouseItem.getQuantity());
        whs.setAllocatedStock(allocatedStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.allocatedStockSubtract(whs);
    }


    /**
     * 弃审“已完成”其他出库
     * @param warehouseItem
     * @return
     */
    public int preCancelOtherOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
       /* BigDecimal stock = whs.getStock().add(warehouseItem.getQuantity());
        BigDecimal allocatedStock = whs.getAllocatedStock().add(warehouseItem.getQuantity());
        whs.setStock(stock);
        whs.setAllocatedStock(allocatedStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.stockPlusAndAllocatedPlus(whs);
    }


    /**
     * 弃审“已确认”其他出库
     * @param warehouseItem
     * @return
     */
    public int afterCancelOtherOut(WarehouseItem warehouseItem){
        WarehouseStock whs = selectStock(warehouseItem);
    /*    BigDecimal allocatedStock = whs.getAllocatedStock().subtract(warehouseItem.getQuantity());
        whs.setAllocatedStock(allocatedStock);*/
        whs.setQuantity(warehouseItem.getMainProductQuantity());
        return warehouseStockMapper.allocatedStockSubtract(whs);
    }
}
